var Module = (() => {
  var _scriptDir = import.meta.url;

  return (
    async function (moduleArg = {}) {

      var Module = moduleArg;
      var readyPromiseResolve, readyPromiseReject;
      Module["ready"] = new Promise((resolve, reject) => {
        readyPromiseResolve = resolve;
        readyPromiseReject = reject
      });
      var Module = typeof Module != "undefined" ? Module : {};
      Module["locateFile"] = function (url) {
        if (url == "decoder-pro-simd-mt-worker.wasm"
          && typeof JESSIBUCA_PRO_SIMD_MT_WORKER_WASM_URL != "undefined"
          && JESSIBUCA_PRO_SIMD_MT_WORKER_WASM_URL
          != "") {
          return JESSIBUCA_PRO_SIMD_MT_WORKER_WASM_URL;
        } else {
          return url;
        }
        if (url == "decoder-pro-simd-mt-worker.worker.js"
          && typeof JESSIBUCA_PRO_SIMD_MT_WORKER_JS_URL != "undefined"
          && JESSIBUCA_PRO_SIMD_MT_WORKER_JS_URL != "") {
          return JESSIBUCA_PRO_SIMD_MT_WORKER_JS_URL
        } else {
          return url
        }
      };
      var moduleOverrides = Object.assign({}, Module);
      var arguments_ = [];
      var thisProgram = "./this.program";
      var quit_ = (status, toThrow) => {
        throw toThrow
      };
      var ENVIRONMENT_IS_WEB = typeof window == "object";
      var ENVIRONMENT_IS_WORKER = typeof importScripts == "function";
      var ENVIRONMENT_IS_NODE = typeof process == "object"
        && typeof process.versions == "object" && typeof process.versions.node
        == "string";
      var ENVIRONMENT_IS_PTHREAD = Module["ENVIRONMENT_IS_PTHREAD"] || false;
      var scriptDirectory = "";

      function locateFile(path) {
        if (Module["locateFile"]) {
          return Module["locateFile"](path, scriptDirectory)
        }
        return scriptDirectory + path
      }

      var read_, readAsync, readBinary;
      if (ENVIRONMENT_IS_NODE) {
        const {createRequire: createRequire} = await import("module");
        var require = createRequire(import.meta.url);
        var fs = require("fs");
        var nodePath = require("path");
        if (ENVIRONMENT_IS_WORKER) {
          scriptDirectory = nodePath.dirname(scriptDirectory) + "/"
        } else {
          scriptDirectory = require("url").fileURLToPath(
            new URL("./", import.meta.url))
        }
        read_ = (filename, binary) => {
          filename = isFileURI(filename) ? new URL(filename)
            : nodePath.normalize(filename);
          return fs.readFileSync(filename, binary ? undefined : "utf8")
        };
        readBinary = filename => {
          var ret = read_(filename, true);
          if (!ret.buffer) {
            ret = new Uint8Array(ret)
          }
          return ret
        };
        readAsync = (filename, onload, onerror, binary = true) => {
          filename = isFileURI(filename) ? new URL(filename)
            : nodePath.normalize(filename);
          fs.readFile(filename, binary ? undefined : "utf8", (err, data) => {
            if (err) {
              onerror(err);
            } else {
              onload(binary ? data.buffer : data)
            }
          })
        };
        if (!Module["thisProgram"] && process.argv.length > 1) {
          thisProgram = process.argv[1].replace(/\\/g, "/")
        }
        arguments_ = process.argv.slice(2);
        quit_ = (status, toThrow) => {
          process.exitCode = status;
          throw toThrow
        };
        Module["inspect"] = () => "[Emscripten Module object]";
        let nodeWorkerThreads;
        try {
          nodeWorkerThreads = require("worker_threads")
        } catch (e) {
          console.error(
            'The "worker_threads" module is not supported in this node.js build - perhaps a newer version is needed?');
          throw e
        }
        global.Worker = nodeWorkerThreads.Worker
      } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
        if (ENVIRONMENT_IS_WORKER) {
          scriptDirectory = self.location.href
        } else if (typeof document != "undefined" && document.currentScript) {
          scriptDirectory = document.currentScript.src
        }
        if (_scriptDir) {
          scriptDirectory = _scriptDir
        }
        if (scriptDirectory.indexOf("blob:") !== 0) {
          scriptDirectory = scriptDirectory.substr(0,
            scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1)
        } else {
          scriptDirectory = ""
        }
        if (!ENVIRONMENT_IS_NODE) {
          read_ = url => {
            var xhr = new XMLHttpRequest;
            xhr.open("GET", url, false);
            xhr.send(null);
            return xhr.responseText
          };
          if (ENVIRONMENT_IS_WORKER) {
            readBinary = url => {
              var xhr = new XMLHttpRequest;
              xhr.open("GET", url, false);
              xhr.responseType = "arraybuffer";
              xhr.send(null);
              return new Uint8Array(xhr.response)
            }
          }
          readAsync = (url, onload, onerror) => {
            var xhr = new XMLHttpRequest;
            xhr.open("GET", url, true);
            xhr.responseType = "arraybuffer";
            xhr.onload = () => {
              if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
                onload(xhr.response);
                return
              }
              onerror()
            };
            xhr.onerror = onerror;
            xhr.send(null)
          }
        }
      } else {
      }
      if (ENVIRONMENT_IS_NODE) {
        if (typeof performance == "undefined") {
          global.performance = require("perf_hooks").performance
        }
      }
      var defaultPrint = console.log.bind(console);
      var defaultPrintErr = console.error.bind(console);
      if (ENVIRONMENT_IS_NODE) {
        defaultPrint = (...args) => fs.writeSync(1, args.join(" ") + "\n");
        defaultPrintErr = (...args) => fs.writeSync(2, args.join(" ") + "\n")
      }
      var out = Module["print"] || defaultPrint;
      var err = Module["printErr"] || defaultPrintErr;
      Object.assign(Module, moduleOverrides);
      moduleOverrides = null;
      if (Module["arguments"]) {
        arguments_ = Module["arguments"];
      }
      if (Module["thisProgram"]) {
        thisProgram = Module["thisProgram"];
      }
      if (Module["quit"]) {
        quit_ = Module["quit"];
      }
      var wasmBinary;
      if (Module["wasmBinary"]) {
        wasmBinary = Module["wasmBinary"];
      }
      var noExitRuntime = Module["noExitRuntime"] || true;
      if (typeof WebAssembly != "object") {
        abort("no native wasm support detected")
      }
      var wasmMemory;
      var wasmModule;
      var ABORT = false;
      var EXITSTATUS;

      function assert(condition, text) {
        if (!condition) {
          abort(text)
        }
      }

      var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;

      function updateMemoryViews() {
        var b = wasmMemory.buffer;
        Module["HEAP8"] = HEAP8 = new Int8Array(b);
        Module["HEAP16"] = HEAP16 = new Int16Array(b);
        Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
        Module["HEAPU16"] = HEAPU16 = new Uint16Array(b);
        Module["HEAP32"] = HEAP32 = new Int32Array(b);
        Module["HEAPU32"] = HEAPU32 = new Uint32Array(b);
        Module["HEAPF32"] = HEAPF32 = new Float32Array(b);
        Module["HEAPF64"] = HEAPF64 = new Float64Array(b)
      }

      var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 536870912;
      assert(INITIAL_MEMORY >= 16777216,
        "INITIAL_MEMORY should be larger than STACK_SIZE, was " + INITIAL_MEMORY
        + "! (STACK_SIZE=" + 16777216 + ")");
      if (ENVIRONMENT_IS_PTHREAD) {
        wasmMemory = Module["wasmMemory"]
      } else {
        if (Module["wasmMemory"]) {
          wasmMemory = Module["wasmMemory"]
        } else {
          wasmMemory = new WebAssembly.Memory({
            "initial": INITIAL_MEMORY / 65536,
            "maximum": INITIAL_MEMORY / 65536,
            "shared": true
          });
          if (!(wasmMemory.buffer instanceof SharedArrayBuffer)) {
            err(
              "requested a shared WebAssembly.Memory but the returned buffer is not a SharedArrayBuffer, indicating that while the browser has SharedArrayBuffer it does not have WebAssembly threads support - you may need to set a flag");
            if (ENVIRONMENT_IS_NODE) {
              err(
                "(on node you may need: --experimental-wasm-threads --experimental-wasm-bulk-memory and/or recent version)")
            }
            throw Error("bad memory")
          }
        }
      }
      updateMemoryViews();
      INITIAL_MEMORY = wasmMemory.buffer.byteLength;
      var __ATPRERUN__ = [];
      var __ATINIT__ = [];
      var __ATPOSTRUN__ = [];
      var runtimeInitialized = false;
      var runtimeKeepaliveCounter = 0;

      function keepRuntimeAlive() {
        return noExitRuntime || runtimeKeepaliveCounter > 0
      }

      function preRun() {
        if (Module["preRun"]) {
          if (typeof Module["preRun"]
            == "function") {
            Module["preRun"] = [Module["preRun"]];
          }
          while (Module["preRun"].length) {
            addOnPreRun(Module["preRun"].shift())
          }
        }
        callRuntimeCallbacks(__ATPRERUN__)
      }

      function initRuntime() {
        runtimeInitialized = true;
        if (ENVIRONMENT_IS_PTHREAD) {
          return;
        }
        callRuntimeCallbacks(__ATINIT__)
      }

      function postRun() {
        if (ENVIRONMENT_IS_PTHREAD) {
          return;
        }
        if (Module["postRun"]) {
          if (typeof Module["postRun"]
            == "function") {
            Module["postRun"] = [Module["postRun"]];
          }
          while (Module["postRun"].length) {
            addOnPostRun(Module["postRun"].shift())
          }
        }
        callRuntimeCallbacks(__ATPOSTRUN__)
      }

      function addOnPreRun(cb) {
        __ATPRERUN__.unshift(cb)
      }

      function addOnInit(cb) {
        __ATINIT__.unshift(cb)
      }

      function addOnPostRun(cb) {
        __ATPOSTRUN__.unshift(cb)
      }

      var runDependencies = 0;
      var runDependencyWatcher = null;
      var dependenciesFulfilled = null;

      function addRunDependency(id) {
        runDependencies++;
        if (Module["monitorRunDependencies"]) {
          Module["monitorRunDependencies"](runDependencies)
        }
      }

      function removeRunDependency(id) {
        runDependencies--;
        if (Module["monitorRunDependencies"]) {
          Module["monitorRunDependencies"](runDependencies)
        }
        if (runDependencies == 0) {
          if (runDependencyWatcher !== null) {
            clearInterval(runDependencyWatcher);
            runDependencyWatcher = null
          }
          if (dependenciesFulfilled) {
            var callback = dependenciesFulfilled;
            dependenciesFulfilled = null;
            callback()
          }
        }
      }

      function abort(what) {
        if (Module["onAbort"]) {
          Module["onAbort"](what)
        }
        what = "Aborted(" + what + ")";
        err(what);
        ABORT = true;
        EXITSTATUS = 1;
        what += ". Build with -sASSERTIONS for more info.";
        var e = new WebAssembly.RuntimeError(what);
        readyPromiseReject(e);
        throw e
      }

      var dataURIPrefix = "data:application/octet-stream;base64,";

      function isDataURI(filename) {
        return filename.startsWith(dataURIPrefix)
      }

      function isFileURI(filename) {
        return filename.startsWith("file://")
      }

      var wasmBinaryFile;
      if (Module["locateFile"]) {
        wasmBinaryFile = "decoder-pro-simd-mt-worker.wasm";
        if (!isDataURI(wasmBinaryFile)) {
          wasmBinaryFile = locateFile(wasmBinaryFile)
        }
      } else {
        wasmBinaryFile = new URL("decoder-pro-simd-mt-worker.wasm",
          import.meta.url).href
      }

      function getBinarySync(file) {
        if (file == wasmBinaryFile && wasmBinary) {
          return new Uint8Array(wasmBinary)
        }
        if (readBinary) {
          return readBinary(file)
        }
        throw "both async and sync fetching of the wasm failed"
      }

      function getBinaryPromise(binaryFile) {
        if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
          if (typeof fetch == "function" && !isFileURI(binaryFile)) {
            return fetch(binaryFile, {credentials: "same-origin"}).then(
              response => {
                if (!response["ok"]) {
                  throw "failed to load wasm binary file at '" + binaryFile
                  + "'"
                }
                return response["arrayBuffer"]()
              }).catch(() => getBinarySync(binaryFile))
          } else if (readAsync) {
            return new Promise((resolve, reject) => {
              readAsync(binaryFile,
                response => resolve(new Uint8Array(response)), reject)
            })
          }
        }
        return Promise.resolve().then(() => getBinarySync(binaryFile))
      }

      function instantiateArrayBuffer(binaryFile, imports, receiver) {
        return getBinaryPromise(binaryFile).then(
          binary => WebAssembly.instantiate(binary, imports)).then(
          instance => instance).then(receiver, reason => {
          err(`failed to asynchronously prepare wasm: ${reason}`);
          abort(reason)
        })
      }

      function instantiateAsync(binary, binaryFile, imports, callback) {
        if (!binary && typeof WebAssembly.instantiateStreaming == "function"
          && !isDataURI(binaryFile) && !isFileURI(binaryFile)
          && !ENVIRONMENT_IS_NODE && typeof fetch == "function") {
          return fetch(binaryFile, {credentials: "same-origin"}).then(
            response => {
              var result = WebAssembly.instantiateStreaming(response, imports);
              return result.then(callback, function (reason) {
                err(`wasm streaming compile failed: ${reason}`);
                err("falling back to ArrayBuffer instantiation");
                return instantiateArrayBuffer(binaryFile, imports, callback)
              })
            })
        }
        return instantiateArrayBuffer(binaryFile, imports, callback)
      }

      function createWasm() {
        var info = {"a": wasmImports};

        function receiveInstance(instance, module) {
          wasmExports = instance.exports;
          registerTLSInit(wasmExports["O"]);
          wasmTable = wasmExports["T"];
          addOnInit(wasmExports["L"]);
          wasmModule = module;
          removeRunDependency("wasm-instantiate");
          return wasmExports
        }

        addRunDependency("wasm-instantiate");

        function receiveInstantiationResult(result) {
          receiveInstance(result["instance"], result["module"])
        }

        if (Module["instantiateWasm"]) {
          try {
            return Module["instantiateWasm"](info, receiveInstance)
          } catch (e) {
            err(`Module.instantiateWasm callback failed with error: ${e}`);
            readyPromiseReject(e)
          }
        }
        instantiateAsync(wasmBinary, wasmBinaryFile, info,
          receiveInstantiationResult).catch(readyPromiseReject);
        return {}
      }

      function ExitStatus(status) {
        this.name = "ExitStatus";
        this.message = `Program terminated with exit(${status})`;
        this.status = status
      }

      var terminateWorker = worker => {
        worker.terminate();
        worker.onmessage = e => {
        }
      };
      var killThread = pthread_ptr => {
        var worker = PThread.pthreads[pthread_ptr];
        delete PThread.pthreads[pthread_ptr];
        terminateWorker(worker);
        __emscripten_thread_free_data(pthread_ptr);
        PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker),
          1);
        worker.pthread_ptr = 0
      };
      var cancelThread = pthread_ptr => {
        var worker = PThread.pthreads[pthread_ptr];
        worker.postMessage({"cmd": "cancel"})
      };
      var cleanupThread = pthread_ptr => {
        var worker = PThread.pthreads[pthread_ptr];
        assert(worker);
        PThread.returnWorkerToPool(worker)
      };
      var spawnThread = threadParams => {
        var worker = PThread.getNewWorker();
        if (!worker) {
          return 6
        }
        PThread.runningWorkers.push(worker);
        PThread.pthreads[threadParams.pthread_ptr] = worker;
        worker.pthread_ptr = threadParams.pthread_ptr;
        var msg = {
          "cmd": "run",
          "start_routine": threadParams.startRoutine,
          "arg": threadParams.arg,
          "pthread_ptr": threadParams.pthread_ptr
        };
        if (ENVIRONMENT_IS_NODE) {
          worker.unref()
        }
        worker.postMessage(msg, threadParams.transferList);
        return 0
      };
      var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder(
        "utf8") : undefined;
      var UTF8ArrayToString = (heapOrArray, idx, maxBytesToRead) => {
        var endIdx = idx + maxBytesToRead;
        var endPtr = idx;
        while (heapOrArray[endPtr] && !(endPtr >= endIdx)) {
          ++endPtr;
        }
        if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
          return UTF8Decoder.decode(
            heapOrArray.buffer instanceof SharedArrayBuffer ? heapOrArray.slice(
              idx, endPtr) : heapOrArray.subarray(idx, endPtr))
        }
        var str = "";
        while (idx < endPtr) {
          var u0 = heapOrArray[idx++];
          if (!(u0 & 128)) {
            str += String.fromCharCode(u0);
            continue
          }
          var u1 = heapOrArray[idx++] & 63;
          if ((u0 & 224) == 192) {
            str += String.fromCharCode((u0 & 31) << 6 | u1);
            continue
          }
          var u2 = heapOrArray[idx++] & 63;
          if ((u0 & 240) == 224) {
            u0 = (u0 & 15) << 12 | u1 << 6 | u2
          } else {
            u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63
          }
          if (u0 < 65536) {
            str += String.fromCharCode(u0)
          } else {
            var ch = u0 - 65536;
            str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023)
          }
        }
        return str
      };
      var UTF8ToString = (ptr, maxBytesToRead) => ptr ? UTF8ArrayToString(
        HEAPU8, ptr, maxBytesToRead) : "";
      var SYSCALLS = {
        varargs: undefined, get() {
          var ret = HEAP32[+SYSCALLS.varargs >> 2];
          SYSCALLS.varargs += 4;
          return ret
        }, getp() {
          return SYSCALLS.get()
        }, getStr(ptr) {
          var ret = UTF8ToString(ptr);
          return ret
        }
      };

      function _proc_exit(code) {
        if (ENVIRONMENT_IS_PTHREAD) {
          return proxyToMainThread(0, 1, code);
        }
        EXITSTATUS = code;
        if (!keepRuntimeAlive()) {
          PThread.terminateAllThreads();
          if (Module["onExit"]) {
            Module["onExit"](code);
          }
          ABORT = true
        }
        quit_(code, new ExitStatus(code))
      }

      var exitJS = (status, implicit) => {
        EXITSTATUS = status;
        if (ENVIRONMENT_IS_PTHREAD) {
          exitOnMainThread(status);
          throw "unwind"
        }
        _proc_exit(status)
      };
      var _exit = exitJS;
      var handleException = e => {
        if (e instanceof ExitStatus || e == "unwind") {
          return EXITSTATUS
        }
        quit_(1, e)
      };
      var PThread = {
        unusedWorkers: [],
        runningWorkers: [],
        tlsInitFunctions: [],
        pthreads: {},
        init() {
          if (ENVIRONMENT_IS_PTHREAD) {
            PThread.initWorker()
          } else {
            PThread.initMainThread()
          }
        },
        initMainThread() {
          var pthreadPoolSize = 8;
          while (pthreadPoolSize--) {
            PThread.allocateUnusedWorker()
          }
          addOnPreRun(() => {
            addRunDependency("loading-workers");
            PThread.loadWasmModuleToAllWorkers(
              () => removeRunDependency("loading-workers"))
          })
        },
        initWorker() {
          noExitRuntime = false
        },
        setExitStatus: status => {
          EXITSTATUS = status
        },
        terminateAllThreads__deps: ["$terminateWorker"],
        terminateAllThreads: () => {
          for (var worker of PThread.runningWorkers) {
            terminateWorker(worker)
          }
          for (var worker of PThread.unusedWorkers) {
            terminateWorker(worker)
          }
          PThread.unusedWorkers = [];
          PThread.runningWorkers = [];
          PThread.pthreads = []
        },
        returnWorkerToPool: worker => {
          var pthread_ptr = worker.pthread_ptr;
          delete PThread.pthreads[pthread_ptr];
          PThread.unusedWorkers.push(worker);
          PThread.runningWorkers.splice(PThread.runningWorkers.indexOf(worker),
            1);
          worker.pthread_ptr = 0;
          __emscripten_thread_free_data(pthread_ptr)
        },
        receiveObjectTransfer(data) {
        },
        threadInitTLS() {
          PThread.tlsInitFunctions.forEach(f => f())
        },
        loadWasmModuleToWorker: worker => new Promise(onFinishedLoading => {
          worker.onmessage = e => {
            var d = e["data"];
            var cmd = d["cmd"];
            if (d["targetThread"] && d["targetThread"] != _pthread_self()) {
              var targetWorker = PThread.pthreads[d["targetThread"]];
              if (targetWorker) {
                targetWorker.postMessage(d, d["transferList"])
              } else {
                err(
                  `Internal error! Worker sent a message "${cmd}" to target pthread ${d["targetThread"]}, but that thread no longer exists!`)
              }
              return
            }
            if (cmd === "checkMailbox") {
              checkMailbox()
            } else if (cmd === "spawnThread") {
              spawnThread(d)
            } else if (cmd === "cleanupThread") {
              cleanupThread(d["thread"])
            } else if (cmd === "killThread") {
              killThread(d["thread"])
            } else if (cmd === "cancelThread") {
              cancelThread(d["thread"])
            } else if (cmd === "loaded") {
              worker.loaded = true;
              if (ENVIRONMENT_IS_NODE && !worker.pthread_ptr) {
                worker.unref()
              }
              onFinishedLoading(worker)
            } else if (cmd === "alert") {
              alert(`Thread ${d["threadId"]}: ${d["text"]}`)
            } else if (d.target === "setimmediate") {
              worker.postMessage(d)
            } else if (cmd === "callHandler") {
              Module[d["handler"]](...d["args"])
            } else if (cmd) {
              err(`worker sent an unknown command ${cmd}`)
            }
          };
          worker.onerror = e => {
            var message = "worker sent an error!";
            err(`${message} ${e.filename}:${e.lineno}: ${e.message}`);
            throw e
          };
          if (ENVIRONMENT_IS_NODE) {
            worker.on("message", data => worker.onmessage({data: data}));
            worker.on("error", e => worker.onerror(e))
          }
          var handlers = [];
          var knownHandlers = ["onExit", "onAbort", "print", "printErr"];
          for (var handler of knownHandlers) {
            if (Module.hasOwnProperty(handler)) {
              handlers.push(handler)
            }
          }
          worker.postMessage({
            "cmd": "load",
            "handlers": handlers,
            "urlOrBlob": Module["mainScriptUrlOrBlob"],
            "wasmMemory": wasmMemory,
            "wasmModule": wasmModule
          })
        }),
        loadWasmModuleToAllWorkers(onMaybeReady) {
          if (ENVIRONMENT_IS_PTHREAD) {
            return onMaybeReady()
          }
          let pthreadPoolReady = Promise.all(
            PThread.unusedWorkers.map(PThread.loadWasmModuleToWorker));
          pthreadPoolReady.then(onMaybeReady)
        },
        allocateUnusedWorker() {
          var worker;
          if (!Module["locateFile"]) {
            worker = new Worker(
              new URL("decoder-pro-simd-mt-worker.worker.js", import.meta.url))
          } else {
            var pthreadMainJs = locateFile(
              "decoder-pro-simd-mt-worker.worker.js");
            worker = new Worker(pthreadMainJs)
          }
          PThread.unusedWorkers.push(worker)
        },
        getNewWorker() {
          if (PThread.unusedWorkers.length == 0) {
            PThread.allocateUnusedWorker();
            PThread.loadWasmModuleToWorker(PThread.unusedWorkers[0])
          }
          return PThread.unusedWorkers.pop()
        }
      };
      Module["PThread"] = PThread;
      var callRuntimeCallbacks = callbacks => {
        while (callbacks.length > 0) {
          callbacks.shift()(Module)
        }
      };
      var establishStackSpace = () => {
        var pthread_ptr = _pthread_self();
        var stackHigh = HEAPU32[pthread_ptr + 52 >> 2];
        var stackSize = HEAPU32[pthread_ptr + 56 >> 2];
        var stackLow = stackHigh - stackSize;
        _emscripten_stack_set_limits(stackHigh, stackLow);
        stackRestore(stackHigh)
      };
      Module["establishStackSpace"] = establishStackSpace;

      function exitOnMainThread(returnCode) {
        if (ENVIRONMENT_IS_PTHREAD) {
          return proxyToMainThread(1, 0, returnCode);
        }
        _exit(returnCode)
      }

      var wasmTableMirror = [];
      var wasmTable;
      var getWasmTableEntry = funcPtr => {
        var func = wasmTableMirror[funcPtr];
        if (!func) {
          if (funcPtr
            >= wasmTableMirror.length) {
            wasmTableMirror.length = funcPtr + 1;
          }
          wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr)
        }
        return func
      };
      var invokeEntryPoint = (ptr, arg) => {
        var result = getWasmTableEntry(ptr)(arg);

        function finish(result) {
          if (keepRuntimeAlive()) {
            PThread.setExitStatus(result)
          } else {
            __emscripten_thread_exit(result)
          }
        }

        finish(result)
      };
      Module["invokeEntryPoint"] = invokeEntryPoint;
      var registerTLSInit = tlsInitFunc => {
        PThread.tlsInitFunctions.push(tlsInitFunc)
      };

      function ExceptionInfo(excPtr) {
        this.excPtr = excPtr;
        this.ptr = excPtr - 24;
        this.set_type = function (type) {
          HEAPU32[this.ptr + 4 >> 2] = type
        };
        this.get_type = function () {
          return HEAPU32[this.ptr + 4 >> 2]
        };
        this.set_destructor = function (destructor) {
          HEAPU32[this.ptr + 8 >> 2] = destructor
        };
        this.get_destructor = function () {
          return HEAPU32[this.ptr + 8 >> 2]
        };
        this.set_caught = function (caught) {
          caught = caught ? 1 : 0;
          HEAP8[this.ptr + 12 >> 0] = caught
        };
        this.get_caught = function () {
          return HEAP8[this.ptr + 12 >> 0] != 0
        };
        this.set_rethrown = function (rethrown) {
          rethrown = rethrown ? 1 : 0;
          HEAP8[this.ptr + 13 >> 0] = rethrown
        };
        this.get_rethrown = function () {
          return HEAP8[this.ptr + 13 >> 0] != 0
        };
        this.init = function (type, destructor) {
          this.set_adjusted_ptr(0);
          this.set_type(type);
          this.set_destructor(destructor)
        };
        this.set_adjusted_ptr = function (adjustedPtr) {
          HEAPU32[this.ptr + 16 >> 2] = adjustedPtr
        };
        this.get_adjusted_ptr = function () {
          return HEAPU32[this.ptr + 16 >> 2]
        };
        this.get_exception_ptr = function () {
          var isPointer = ___cxa_is_pointer_type(this.get_type());
          if (isPointer) {
            return HEAPU32[this.excPtr >> 2]
          }
          var adjusted = this.get_adjusted_ptr();
          if (adjusted !== 0) {
            return adjusted;
          }
          return this.excPtr
        }
      }

      var exceptionLast = 0;
      var uncaughtExceptionCount = 0;
      var ___cxa_throw = (ptr, type, destructor) => {
        var info = new ExceptionInfo(ptr);
        info.init(type, destructor);
        exceptionLast = ptr;
        uncaughtExceptionCount++;
        throw exceptionLast
      };
      var ___emscripten_init_main_thread_js = tb => {
        __emscripten_thread_init(tb, !ENVIRONMENT_IS_WORKER, 1,
          !ENVIRONMENT_IS_WEB, 16777216, false);
        PThread.threadInitTLS()
      };
      var ___emscripten_thread_cleanup = thread => {
        if (!ENVIRONMENT_IS_PTHREAD) {
          cleanupThread(thread);
        } else {
          postMessage(
            {"cmd": "cleanupThread", "thread": thread})
        }
      };

      function pthreadCreateProxied(pthread_ptr, attr, startRoutine, arg) {
        if (ENVIRONMENT_IS_PTHREAD) {
          return proxyToMainThread(2, 1, pthread_ptr,
            attr, startRoutine, arg);
        }
        return ___pthread_create_js(pthread_ptr, attr, startRoutine, arg)
      }

      var ___pthread_create_js = (pthread_ptr, attr, startRoutine, arg) => {
        if (typeof SharedArrayBuffer == "undefined") {
          err(
            "Current environment does not support SharedArrayBuffer, pthreads are not available!");
          return 6
        }
        var transferList = [];
        var error = 0;
        if (ENVIRONMENT_IS_PTHREAD && (transferList.length === 0 || error)) {
          return pthreadCreateProxied(pthread_ptr, attr, startRoutine, arg)
        }
        if (error) {
          return error;
        }
        var threadParams = {
          startRoutine: startRoutine,
          pthread_ptr: pthread_ptr,
          arg: arg,
          transferList: transferList
        };
        if (ENVIRONMENT_IS_PTHREAD) {
          threadParams.cmd = "spawnThread";
          postMessage(threadParams, transferList);
          return 0
        }
        return spawnThread(threadParams)
      };
      var __embind_register_bigint = (primitiveType, name, size, minRange,
        maxRange) => {
      };
      var embind_init_charCodes = () => {
        var codes = new Array(256);
        for (var i = 0; i < 256; ++i) {
          codes[i] = String.fromCharCode(i)
        }
        embind_charCodes = codes
      };
      var embind_charCodes;
      var readLatin1String = ptr => {
        var ret = "";
        var c = ptr;
        while (HEAPU8[c]) {
          ret += embind_charCodes[HEAPU8[c++]]
        }
        return ret
      };
      var awaitingDependencies = {};
      var registeredTypes = {};
      var typeDependencies = {};
      var BindingError;
      var throwBindingError = message => {
        throw new BindingError(message)
      };
      var InternalError;
      var throwInternalError = message => {
        throw new InternalError(message)
      };
      var whenDependentTypesAreResolved = (myTypes, dependentTypes,
        getTypeConverters) => {
        myTypes.forEach(function (type) {
          typeDependencies[type] = dependentTypes
        });

        function onComplete(typeConverters) {
          var myTypeConverters = getTypeConverters(typeConverters);
          if (myTypeConverters.length !== myTypes.length) {
            throwInternalError("Mismatched type converter count")
          }
          for (var i = 0; i < myTypes.length; ++i) {
            registerType(myTypes[i], myTypeConverters[i])
          }
        }

        var typeConverters = new Array(dependentTypes.length);
        var unregisteredTypes = [];
        var registered = 0;
        dependentTypes.forEach((dt, i) => {
          if (registeredTypes.hasOwnProperty(dt)) {
            typeConverters[i] = registeredTypes[dt]
          } else {
            unregisteredTypes.push(dt);
            if (!awaitingDependencies.hasOwnProperty(dt)) {
              awaitingDependencies[dt] = []
            }
            awaitingDependencies[dt].push(() => {
              typeConverters[i] = registeredTypes[dt];
              ++registered;
              if (registered === unregisteredTypes.length) {
                onComplete(typeConverters)
              }
            })
          }
        });
        if (0 === unregisteredTypes.length) {
          onComplete(typeConverters)
        }
      };

      function sharedRegisterType(rawType, registeredInstance, options = {}) {
        var name = registeredInstance.name;
        if (!rawType) {
          throwBindingError(
            `type "${name}" must have a positive integer typeid pointer`)
        }
        if (registeredTypes.hasOwnProperty(rawType)) {
          if (options.ignoreDuplicateRegistrations) {
            return
          } else {
            throwBindingError(`Cannot register type '${name}' twice`)
          }
        }
        registeredTypes[rawType] = registeredInstance;
        delete typeDependencies[rawType];
        if (awaitingDependencies.hasOwnProperty(rawType)) {
          var callbacks = awaitingDependencies[rawType];
          delete awaitingDependencies[rawType];
          callbacks.forEach(cb => cb())
        }
      }

      function registerType(rawType, registeredInstance, options = {}) {
        if (!("argPackAdvance" in registeredInstance)) {
          throw new TypeError(
            "registerType registeredInstance requires argPackAdvance")
        }
        return sharedRegisterType(rawType, registeredInstance, options)
      }

      var GenericWireTypeSize = 8;
      var __embind_register_bool = (rawType, name, trueValue, falseValue) => {
        name = readLatin1String(name);
        registerType(rawType, {
          name: name,
          "fromWireType": function (wt) {
            return !!wt
          },
          "toWireType": function (destructors, o) {
            return o ? trueValue : falseValue
          },
          "argPackAdvance": GenericWireTypeSize,
          "readValueFromPointer": function (pointer) {
            return this["fromWireType"](HEAPU8[pointer])
          },
          destructorFunction: null
        })
      };
      var shallowCopyInternalPointer = o => ({
        count: o.count,
        deleteScheduled: o.deleteScheduled,
        preservePointerOnDelete: o.preservePointerOnDelete,
        ptr: o.ptr,
        ptrType: o.ptrType,
        smartPtr: o.smartPtr,
        smartPtrType: o.smartPtrType
      });
      var throwInstanceAlreadyDeleted = obj => {
        function getInstanceTypeName(handle) {
          return handle.$$.ptrType.registeredClass.name
        }

        throwBindingError(
          getInstanceTypeName(obj) + " instance already deleted")
      };
      var finalizationRegistry = false;
      var detachFinalizer = handle => {
      };
      var runDestructor = $$ => {
        if ($$.smartPtr) {
          $$.smartPtrType.rawDestructor($$.smartPtr)
        } else {
          $$.ptrType.registeredClass.rawDestructor($$.ptr)
        }
      };
      var releaseClassHandle = $$ => {
        $$.count.value -= 1;
        var toDelete = 0 === $$.count.value;
        if (toDelete) {
          runDestructor($$)
        }
      };
      var downcastPointer = (ptr, ptrClass, desiredClass) => {
        if (ptrClass === desiredClass) {
          return ptr
        }
        if (undefined === desiredClass.baseClass) {
          return null
        }
        var rv = downcastPointer(ptr, ptrClass, desiredClass.baseClass);
        if (rv === null) {
          return null
        }
        return desiredClass.downcast(rv)
      };
      var registeredPointers = {};
      var getInheritedInstanceCount = () => Object.keys(
        registeredInstances).length;
      var getLiveInheritedInstances = () => {
        var rv = [];
        for (var k in registeredInstances) {
          if (registeredInstances.hasOwnProperty(k)) {
            rv.push(registeredInstances[k])
          }
        }
        return rv
      };
      var deletionQueue = [];
      var flushPendingDeletes = () => {
        while (deletionQueue.length) {
          var obj = deletionQueue.pop();
          obj.$$.deleteScheduled = false;
          obj["delete"]()
        }
      };
      var delayFunction;
      var setDelayFunction = fn => {
        delayFunction = fn;
        if (deletionQueue.length && delayFunction) {
          delayFunction(flushPendingDeletes)
        }
      };
      var init_embind = () => {
        Module["getInheritedInstanceCount"] = getInheritedInstanceCount;
        Module["getLiveInheritedInstances"] = getLiveInheritedInstances;
        Module["flushPendingDeletes"] = flushPendingDeletes;
        Module["setDelayFunction"] = setDelayFunction
      };
      var registeredInstances = {};
      var getBasestPointer = (class_, ptr) => {
        if (ptr === undefined) {
          throwBindingError("ptr should not be undefined")
        }
        while (class_.baseClass) {
          ptr = class_.upcast(ptr);
          class_ = class_.baseClass
        }
        return ptr
      };
      var getInheritedInstance = (class_, ptr) => {
        ptr = getBasestPointer(class_, ptr);
        return registeredInstances[ptr]
      };
      var makeClassHandle = (prototype, record) => {
        if (!record.ptrType || !record.ptr) {
          throwInternalError("makeClassHandle requires ptr and ptrType")
        }
        var hasSmartPtrType = !!record.smartPtrType;
        var hasSmartPtr = !!record.smartPtr;
        if (hasSmartPtrType !== hasSmartPtr) {
          throwInternalError("Both smartPtrType and smartPtr must be specified")
        }
        record.count = {value: 1};
        return attachFinalizer(Object.create(prototype, {$$: {value: record}}))
      };

      function RegisteredPointer_fromWireType(ptr) {
        var rawPointer = this.getPointee(ptr);
        if (!rawPointer) {
          this.destructor(ptr);
          return null
        }
        var registeredInstance = getInheritedInstance(this.registeredClass,
          rawPointer);
        if (undefined !== registeredInstance) {
          if (0 === registeredInstance.$$.count.value) {
            registeredInstance.$$.ptr = rawPointer;
            registeredInstance.$$.smartPtr = ptr;
            return registeredInstance["clone"]()
          } else {
            var rv = registeredInstance["clone"]();
            this.destructor(ptr);
            return rv
          }
        }

        function makeDefaultHandle() {
          if (this.isSmartPointer) {
            return makeClassHandle(this.registeredClass.instancePrototype, {
              ptrType: this.pointeeType,
              ptr: rawPointer,
              smartPtrType: this,
              smartPtr: ptr
            })
          } else {
            return makeClassHandle(this.registeredClass.instancePrototype,
              {ptrType: this, ptr: ptr})
          }
        }

        var actualType = this.registeredClass.getActualType(rawPointer);
        var registeredPointerRecord = registeredPointers[actualType];
        if (!registeredPointerRecord) {
          return makeDefaultHandle.call(this)
        }
        var toType;
        if (this.isConst) {
          toType = registeredPointerRecord.constPointerType
        } else {
          toType = registeredPointerRecord.pointerType
        }
        var dp = downcastPointer(rawPointer, this.registeredClass,
          toType.registeredClass);
        if (dp === null) {
          return makeDefaultHandle.call(this)
        }
        if (this.isSmartPointer) {
          return makeClassHandle(toType.registeredClass.instancePrototype,
            {ptrType: toType, ptr: dp, smartPtrType: this, smartPtr: ptr})
        } else {
          return makeClassHandle(toType.registeredClass.instancePrototype,
            {ptrType: toType, ptr: dp})
        }
      }

      var attachFinalizer = handle => {
        if ("undefined" === typeof FinalizationRegistry) {
          attachFinalizer = handle => handle;
          return handle
        }
        finalizationRegistry = new FinalizationRegistry(info => {
          releaseClassHandle(info.$$)
        });
        attachFinalizer = handle => {
          var $$ = handle.$$;
          var hasSmartPtr = !!$$.smartPtr;
          if (hasSmartPtr) {
            var info = {$$: $$};
            finalizationRegistry.register(handle, info, handle)
          }
          return handle
        };
        detachFinalizer = handle => finalizationRegistry.unregister(handle);
        return attachFinalizer(handle)
      };
      var init_ClassHandle = () => {
        Object.assign(ClassHandle.prototype, {
          "isAliasOf"(other) {
            if (!(this instanceof ClassHandle)) {
              return false
            }
            if (!(other instanceof ClassHandle)) {
              return false
            }
            var leftClass = this.$$.ptrType.registeredClass;
            var left = this.$$.ptr;
            other.$$ = other.$$;
            var rightClass = other.$$.ptrType.registeredClass;
            var right = other.$$.ptr;
            while (leftClass.baseClass) {
              left = leftClass.upcast(left);
              leftClass = leftClass.baseClass
            }
            while (rightClass.baseClass) {
              right = rightClass.upcast(right);
              rightClass = rightClass.baseClass
            }
            return leftClass === rightClass && left === right
          }, "clone"() {
            if (!this.$$.ptr) {
              throwInstanceAlreadyDeleted(this)
            }
            if (this.$$.preservePointerOnDelete) {
              this.$$.count.value += 1;
              return this
            } else {
              var clone = attachFinalizer(
                Object.create(Object.getPrototypeOf(this),
                  {$$: {value: shallowCopyInternalPointer(this.$$)}}));
              clone.$$.count.value += 1;
              clone.$$.deleteScheduled = false;
              return clone
            }
          }, "delete"() {
            if (!this.$$.ptr) {
              throwInstanceAlreadyDeleted(this)
            }
            if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {
              throwBindingError("Object already scheduled for deletion")
            }
            detachFinalizer(this);
            releaseClassHandle(this.$$);
            if (!this.$$.preservePointerOnDelete) {
              this.$$.smartPtr = undefined;
              this.$$.ptr = undefined
            }
          }, "isDeleted"() {
            return !this.$$.ptr
          }, "deleteLater"() {
            if (!this.$$.ptr) {
              throwInstanceAlreadyDeleted(this)
            }
            if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {
              throwBindingError("Object already scheduled for deletion")
            }
            deletionQueue.push(this);
            if (deletionQueue.length === 1 && delayFunction) {
              delayFunction(flushPendingDeletes)
            }
            this.$$.deleteScheduled = true;
            return this
          }
        })
      };

      function ClassHandle() {
      }

      var char_0 = 48;
      var char_9 = 57;
      var makeLegalFunctionName = name => {
        if (undefined === name) {
          return "_unknown"
        }
        name = name.replace(/[^a-zA-Z0-9_]/g, "$");
        var f = name.charCodeAt(0);
        if (f >= char_0 && f <= char_9) {
          return `_${name}`
        }
        return name
      };

      function createNamedFunction(name, body) {
        name = makeLegalFunctionName(name);
        return {
          [name]: function () {
            return body.apply(this, arguments)
          }
        }[name]
      }

      var ensureOverloadTable = (proto, methodName, humanName) => {
        if (undefined === proto[methodName].overloadTable) {
          var prevFunc = proto[methodName];
          proto[methodName] = function () {
            if (!proto[methodName].overloadTable.hasOwnProperty(
              arguments.length)) {
              throwBindingError(
                `Function '${humanName}' called with an invalid number of arguments (${arguments.length}) - expects one of (${proto[methodName].overloadTable})!`)
            }
            return proto[methodName].overloadTable[arguments.length].apply(this,
              arguments)
          };
          proto[methodName].overloadTable = [];
          proto[methodName].overloadTable[prevFunc.argCount] = prevFunc
        }
      };
      var exposePublicSymbol = (name, value, numArguments) => {
        if (Module.hasOwnProperty(name)) {
          if (undefined === numArguments || undefined
            !== Module[name].overloadTable && undefined
            !== Module[name].overloadTable[numArguments]) {
            throwBindingError(`Cannot register public name '${name}' twice`)
          }
          ensureOverloadTable(Module, name, name);
          if (Module.hasOwnProperty(numArguments)) {
            throwBindingError(
              `Cannot register multiple overloads of a function with the same number of arguments (${numArguments})!`)
          }
          Module[name].overloadTable[numArguments] = value
        } else {
          Module[name] = value;
          if (undefined !== numArguments) {
            Module[name].numArguments = numArguments
          }
        }
      };

      function RegisteredClass(name, constructor, instancePrototype,
        rawDestructor, baseClass, getActualType, upcast, downcast) {
        this.name = name;
        this.constructor = constructor;
        this.instancePrototype = instancePrototype;
        this.rawDestructor = rawDestructor;
        this.baseClass = baseClass;
        this.getActualType = getActualType;
        this.upcast = upcast;
        this.downcast = downcast;
        this.pureVirtualFunctions = []
      }

      var upcastPointer = (ptr, ptrClass, desiredClass) => {
        while (ptrClass !== desiredClass) {
          if (!ptrClass.upcast) {
            throwBindingError(
              `Expected null or instance of ${desiredClass.name}, got an instance of ${ptrClass.name}`)
          }
          ptr = ptrClass.upcast(ptr);
          ptrClass = ptrClass.baseClass
        }
        return ptr
      };

      function constNoSmartPtrRawPointerToWireType(destructors, handle) {
        if (handle === null) {
          if (this.isReference) {
            throwBindingError(`null is not a valid ${this.name}`)
          }
          return 0
        }
        if (!handle.$$) {
          throwBindingError(
            `Cannot pass "${embindRepr(handle)}" as a ${this.name}`)
        }
        if (!handle.$$.ptr) {
          throwBindingError(
            `Cannot pass deleted object as a pointer of type ${this.name}`)
        }
        var handleClass = handle.$$.ptrType.registeredClass;
        var ptr = upcastPointer(handle.$$.ptr, handleClass,
          this.registeredClass);
        return ptr
      }

      function genericPointerToWireType(destructors, handle) {
        var ptr;
        if (handle === null) {
          if (this.isReference) {
            throwBindingError(`null is not a valid ${this.name}`)
          }
          if (this.isSmartPointer) {
            ptr = this.rawConstructor();
            if (destructors !== null) {
              destructors.push(this.rawDestructor, ptr)
            }
            return ptr
          } else {
            return 0
          }
        }
        if (!handle.$$) {
          throwBindingError(
            `Cannot pass "${embindRepr(handle)}" as a ${this.name}`)
        }
        if (!handle.$$.ptr) {
          throwBindingError(
            `Cannot pass deleted object as a pointer of type ${this.name}`)
        }
        if (!this.isConst && handle.$$.ptrType.isConst) {
          throwBindingError(
            `Cannot convert argument of type ${handle.$$.smartPtrType
              ? handle.$$.smartPtrType.name
              : handle.$$.ptrType.name} to parameter type ${this.name}`)
        }
        var handleClass = handle.$$.ptrType.registeredClass;
        ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
        if (this.isSmartPointer) {
          if (undefined === handle.$$.smartPtr) {
            throwBindingError("Passing raw pointer to smart pointer is illegal")
          }
          switch (this.sharingPolicy) {
            case 0:
              if (handle.$$.smartPtrType === this) {
                ptr = handle.$$.smartPtr
              } else {
                throwBindingError(
                  `Cannot convert argument of type ${handle.$$.smartPtrType
                    ? handle.$$.smartPtrType.name
                    : handle.$$.ptrType.name} to parameter type ${this.name}`)
              }
              break;
            case 1:
              ptr = handle.$$.smartPtr;
              break;
            case 2:
              if (handle.$$.smartPtrType === this) {
                ptr = handle.$$.smartPtr
              } else {
                var clonedHandle = handle["clone"]();
                ptr = this.rawShare(ptr,
                  Emval.toHandle(() => clonedHandle["delete"]()));
                if (destructors !== null) {
                  destructors.push(this.rawDestructor, ptr)
                }
              }
              break;
            default:
              throwBindingError("Unsupporting sharing policy")
          }
        }
        return ptr
      }

      function nonConstNoSmartPtrRawPointerToWireType(destructors, handle) {
        if (handle === null) {
          if (this.isReference) {
            throwBindingError(`null is not a valid ${this.name}`)
          }
          return 0
        }
        if (!handle.$$) {
          throwBindingError(
            `Cannot pass "${embindRepr(handle)}" as a ${this.name}`)
        }
        if (!handle.$$.ptr) {
          throwBindingError(
            `Cannot pass deleted object as a pointer of type ${this.name}`)
        }
        if (handle.$$.ptrType.isConst) {
          throwBindingError(
            `Cannot convert argument of type ${handle.$$.ptrType.name} to parameter type ${this.name}`)
        }
        var handleClass = handle.$$.ptrType.registeredClass;
        var ptr = upcastPointer(handle.$$.ptr, handleClass,
          this.registeredClass);
        return ptr
      }

      function readPointer(pointer) {
        return this["fromWireType"](HEAPU32[pointer >> 2])
      }

      var init_RegisteredPointer = () => {
        Object.assign(RegisteredPointer.prototype, {
          getPointee(ptr) {
            if (this.rawGetPointee) {
              ptr = this.rawGetPointee(ptr)
            }
            return ptr
          },
          destructor(ptr) {
            if (this.rawDestructor) {
              this.rawDestructor(ptr)
            }
          },
          "argPackAdvance": GenericWireTypeSize,
          "readValueFromPointer": readPointer,
          "deleteObject"(handle) {
            if (handle !== null) {
              handle["delete"]()
            }
          },
          "fromWireType": RegisteredPointer_fromWireType
        })
      };

      function RegisteredPointer(name, registeredClass, isReference, isConst,
        isSmartPointer, pointeeType, sharingPolicy, rawGetPointee,
        rawConstructor, rawShare, rawDestructor) {
        this.name = name;
        this.registeredClass = registeredClass;
        this.isReference = isReference;
        this.isConst = isConst;
        this.isSmartPointer = isSmartPointer;
        this.pointeeType = pointeeType;
        this.sharingPolicy = sharingPolicy;
        this.rawGetPointee = rawGetPointee;
        this.rawConstructor = rawConstructor;
        this.rawShare = rawShare;
        this.rawDestructor = rawDestructor;
        if (!isSmartPointer && registeredClass.baseClass === undefined) {
          if (isConst) {
            this["toWireType"] = constNoSmartPtrRawPointerToWireType;
            this.destructorFunction = null
          } else {
            this["toWireType"] = nonConstNoSmartPtrRawPointerToWireType;
            this.destructorFunction = null
          }
        } else {
          this["toWireType"] = genericPointerToWireType
        }
      }

      var replacePublicSymbol = (name, value, numArguments) => {
        if (!Module.hasOwnProperty(name)) {
          throwInternalError("Replacing nonexistant public symbol")
        }
        if (undefined !== Module[name].overloadTable && undefined
          !== numArguments) {
          Module[name].overloadTable[numArguments] = value
        } else {
          Module[name] = value;
          Module[name].argCount = numArguments
        }
      };
      var dynCallLegacy = (sig, ptr, args) => {
        var f = Module["dynCall_" + sig];
        return args && args.length ? f.apply(null, [ptr].concat(args)) : f.call(
          null, ptr)
      };
      var dynCall = (sig, ptr, args) => {
        if (sig.includes("j")) {
          return dynCallLegacy(sig, ptr, args)
        }
        var rtn = getWasmTableEntry(ptr).apply(null, args);
        return rtn
      };
      var getDynCaller = (sig, ptr) => {
        var argCache = [];
        return function () {
          argCache.length = 0;
          Object.assign(argCache, arguments);
          return dynCall(sig, ptr, argCache)
        }
      };
      var embind__requireFunction = (signature, rawFunction) => {
        signature = readLatin1String(signature);

        function makeDynCaller() {
          if (signature.includes("j")) {
            return getDynCaller(signature, rawFunction)
          }
          return getWasmTableEntry(rawFunction)
        }

        var fp = makeDynCaller();
        if (typeof fp != "function") {
          throwBindingError(
            `unknown function pointer with signature ${signature}: ${rawFunction}`)
        }
        return fp
      };
      var extendError = (baseErrorType, errorName) => {
        var errorClass = createNamedFunction(errorName, function (message) {
          this.name = errorName;
          this.message = message;
          var stack = new Error(message).stack;
          if (stack !== undefined) {
            this.stack = this.toString() + "\n" + stack.replace(
              /^Error(:[^\n]*)?\n/, "")
          }
        });
        errorClass.prototype = Object.create(baseErrorType.prototype);
        errorClass.prototype.constructor = errorClass;
        errorClass.prototype.toString = function () {
          if (this.message === undefined) {
            return this.name
          } else {
            return `${this.name}: ${this.message}`
          }
        };
        return errorClass
      };
      var UnboundTypeError;
      var getTypeName = type => {
        var ptr = ___getTypeName(type);
        var rv = readLatin1String(ptr);
        _free(ptr);
        return rv
      };
      var throwUnboundTypeError = (message, types) => {
        var unboundTypes = [];
        var seen = {};

        function visit(type) {
          if (seen[type]) {
            return
          }
          if (registeredTypes[type]) {
            return
          }
          if (typeDependencies[type]) {
            typeDependencies[type].forEach(visit);
            return
          }
          unboundTypes.push(type);
          seen[type] = true
        }

        types.forEach(visit);
        throw new UnboundTypeError(
          `${message}: ` + unboundTypes.map(getTypeName).join([", "]))
      };
      var __embind_register_class = (rawType, rawPointerType,
        rawConstPointerType, baseClassRawType, getActualTypeSignature,
        getActualType, upcastSignature, upcast, downcastSignature, downcast,
        name, destructorSignature, rawDestructor) => {
        name = readLatin1String(name);
        getActualType = embind__requireFunction(getActualTypeSignature,
          getActualType);
        if (upcast) {
          upcast = embind__requireFunction(upcastSignature, upcast)
        }
        if (downcast) {
          downcast = embind__requireFunction(downcastSignature, downcast)
        }
        rawDestructor = embind__requireFunction(destructorSignature,
          rawDestructor);
        var legalFunctionName = makeLegalFunctionName(name);
        exposePublicSymbol(legalFunctionName, function () {
          throwUnboundTypeError(`Cannot construct ${name} due to unbound types`,
            [baseClassRawType])
        });
        whenDependentTypesAreResolved(
          [rawType, rawPointerType, rawConstPointerType],
          baseClassRawType ? [baseClassRawType] : [], function (base) {
            base = base[0];
            var baseClass;
            var basePrototype;
            if (baseClassRawType) {
              baseClass = base.registeredClass;
              basePrototype = baseClass.instancePrototype
            } else {
              basePrototype = ClassHandle.prototype
            }
            var constructor = createNamedFunction(legalFunctionName,
              function () {
                if (Object.getPrototypeOf(this) !== instancePrototype) {
                  throw new BindingError("Use 'new' to construct " + name)
                }
                if (undefined === registeredClass.constructor_body) {
                  throw new BindingError(
                    name + " has no accessible constructor")
                }
                var body = registeredClass.constructor_body[arguments.length];
                if (undefined === body) {
                  throw new BindingError(
                    `Tried to invoke ctor of ${name} with invalid number of parameters (${arguments.length}) - expected (${Object.keys(
                      registeredClass.constructor_body).toString()}) parameters instead!`)
                }
                return body.apply(this, arguments)
              });
            var instancePrototype = Object.create(basePrototype,
              {constructor: {value: constructor}});
            constructor.prototype = instancePrototype;
            var registeredClass = new RegisteredClass(name, constructor,
              instancePrototype, rawDestructor, baseClass, getActualType,
              upcast, downcast);
            if (registeredClass.baseClass) {
              if (registeredClass.baseClass.__derivedClasses === undefined) {
                registeredClass.baseClass.__derivedClasses = []
              }
              registeredClass.baseClass.__derivedClasses.push(registeredClass)
            }
            var referenceConverter = new RegisteredPointer(name,
              registeredClass, true, false, false);
            var pointerConverter = new RegisteredPointer(name + "*",
              registeredClass, false, false, false);
            var constPointerConverter = new RegisteredPointer(name + " const*",
              registeredClass, false, true, false);
            registeredPointers[rawType] = {
              pointerType: pointerConverter,
              constPointerType: constPointerConverter
            };
            replacePublicSymbol(legalFunctionName, constructor);
            return [referenceConverter, pointerConverter, constPointerConverter]
          })
      };
      var heap32VectorToArray = (count, firstElement) => {
        var array = [];
        for (var i = 0; i < count; i++) {
          array.push(HEAPU32[firstElement + i * 4 >> 2])
        }
        return array
      };
      var runDestructors = destructors => {
        while (destructors.length) {
          var ptr = destructors.pop();
          var del = destructors.pop();
          del(ptr)
        }
      };

      function newFunc(constructor, argumentList) {
        if (!(constructor instanceof Function)) {
          throw new TypeError(
            `new_ called with constructor type ${typeof constructor} which is not a function`)
        }
        var dummy = createNamedFunction(
          constructor.name || "unknownFunctionName", function () {
          });
        dummy.prototype = constructor.prototype;
        var obj = new dummy;
        var r = constructor.apply(obj, argumentList);
        return r instanceof Object ? r : obj
      }

      function craftInvokerFunction(humanName, argTypes, classType,
        cppInvokerFunc, cppTargetFunc, isAsync) {
        var argCount = argTypes.length;
        if (argCount < 2) {
          throwBindingError(
            "argTypes array size mismatch! Must at least get return value and 'this' types!")
        }
        var isClassMethodFunc = argTypes[1] !== null && classType !== null;
        var needsDestructorStack = false;
        for (var i = 1; i < argTypes.length; ++i) {
          if (argTypes[i] !== null && argTypes[i].destructorFunction
            === undefined) {
            needsDestructorStack = true;
            break
          }
        }
        var returns = argTypes[0].name !== "void";
        var argsList = "";
        var argsListWired = "";
        for (var i = 0; i < argCount - 2; ++i) {
          argsList += (i !== 0 ? ", " : "") + "arg" + i;
          argsListWired += (i !== 0 ? ", " : "") + "arg" + i + "Wired"
        }
        var invokerFnBody = `\n        return function ${makeLegalFunctionName(
          humanName)}(${argsList}) {\n        if (arguments.length !== ${argCount
        - 2}) {\n          throwBindingError('function ${humanName} called with ' + arguments.length + ' arguments, expected ${argCount
        - 2}');\n        }`;
        if (needsDestructorStack) {
          invokerFnBody += "var destructors = [];\n"
        }
        var dtorStack = needsDestructorStack ? "destructors" : "null";
        var args1 = ["throwBindingError", "invoker", "fn", "runDestructors",
          "retType", "classParam"];
        var args2 = [throwBindingError, cppInvokerFunc, cppTargetFunc,
          runDestructors, argTypes[0], argTypes[1]];
        if (isClassMethodFunc) {
          invokerFnBody += "var thisWired = classParam.toWireType(" + dtorStack
            + ", this);\n"
        }
        for (var i = 0; i < argCount - 2; ++i) {
          invokerFnBody += "var arg" + i + "Wired = argType" + i
            + ".toWireType(" + dtorStack + ", arg" + i + "); // " + argTypes[i
            + 2].name + "\n";
          args1.push("argType" + i);
          args2.push(argTypes[i + 2])
        }
        if (isClassMethodFunc) {
          argsListWired = "thisWired" + (argsListWired.length > 0 ? ", " : "")
            + argsListWired
        }
        invokerFnBody += (returns || isAsync ? "var rv = " : "") + "invoker(fn"
          + (argsListWired.length > 0 ? ", " : "") + argsListWired + ");\n";
        if (needsDestructorStack) {
          invokerFnBody += "runDestructors(destructors);\n"
        } else {
          for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) {
            var paramName = i === 1 ? "thisWired" : "arg" + (i - 2) + "Wired";
            if (argTypes[i].destructorFunction !== null) {
              invokerFnBody += paramName + "_dtor(" + paramName + "); // "
                + argTypes[i].name + "\n";
              args1.push(paramName + "_dtor");
              args2.push(argTypes[i].destructorFunction)
            }
          }
        }
        if (returns) {
          invokerFnBody += "var ret = retType.fromWireType(rv);\n"
            + "return ret;\n"
        } else {
        }
        invokerFnBody += "}\n";
        args1.push(invokerFnBody);
        return newFunc(Function, args1).apply(null, args2)
      }

      var __embind_register_class_constructor = (rawClassType, argCount,
        rawArgTypesAddr, invokerSignature, invoker, rawConstructor) => {
        var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
        invoker = embind__requireFunction(invokerSignature, invoker);
        whenDependentTypesAreResolved([], [rawClassType], function (classType) {
          classType = classType[0];
          var humanName = `constructor ${classType.name}`;
          if (undefined === classType.registeredClass.constructor_body) {
            classType.registeredClass.constructor_body = []
          }
          if (undefined !== classType.registeredClass.constructor_body[argCount
          - 1]) {
            throw new BindingError(
              `Cannot register multiple constructors with identical number of parameters (${argCount
              - 1}) for class '${classType.name}'! Overload resolution is currently only performed using the parameter count, not actual type info!`)
          }
          classType.registeredClass.constructor_body[argCount - 1] = () => {
            throwUnboundTypeError(
              `Cannot construct ${classType.name} due to unbound types`,
              rawArgTypes)
          };
          whenDependentTypesAreResolved([], rawArgTypes, argTypes => {
            argTypes.splice(1, 0, null);
            classType.registeredClass.constructor_body[argCount
            - 1] = craftInvokerFunction(humanName, argTypes, null, invoker,
              rawConstructor);
            return []
          });
          return []
        })
      };
      var __embind_register_class_function = (rawClassType, methodName,
        argCount, rawArgTypesAddr, invokerSignature, rawInvoker, context,
        isPureVirtual, isAsync) => {
        var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
        methodName = readLatin1String(methodName);
        rawInvoker = embind__requireFunction(invokerSignature, rawInvoker);
        whenDependentTypesAreResolved([], [rawClassType], function (classType) {
          classType = classType[0];
          var humanName = `${classType.name}.${methodName}`;
          if (methodName.startsWith("@@")) {
            methodName = Symbol[methodName.substring(2)]
          }
          if (isPureVirtual) {
            classType.registeredClass.pureVirtualFunctions.push(methodName)
          }

          function unboundTypesHandler() {
            throwUnboundTypeError(
              `Cannot call ${humanName} due to unbound types`, rawArgTypes)
          }

          var proto = classType.registeredClass.instancePrototype;
          var method = proto[methodName];
          if (undefined === method || undefined === method.overloadTable
            && method.className !== classType.name && method.argCount
            === argCount - 2) {
            unboundTypesHandler.argCount = argCount - 2;
            unboundTypesHandler.className = classType.name;
            proto[methodName] = unboundTypesHandler
          } else {
            ensureOverloadTable(proto, methodName, humanName);
            proto[methodName].overloadTable[argCount - 2] = unboundTypesHandler
          }
          whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) {
            var memberFunction = craftInvokerFunction(humanName, argTypes,
              classType, rawInvoker, context, isAsync);
            if (undefined === proto[methodName].overloadTable) {
              memberFunction.argCount = argCount - 2;
              proto[methodName] = memberFunction
            } else {
              proto[methodName].overloadTable[argCount - 2] = memberFunction
            }
            return []
          });
          return []
        })
      };

      function handleAllocatorInit() {
        Object.assign(HandleAllocator.prototype, {
          get(id) {
            return this.allocated[id]
          }, has(id) {
            return this.allocated[id] !== undefined
          }, allocate(handle) {
            var id = this.freelist.pop() || this.allocated.length;
            this.allocated[id] = handle;
            return id
          }, free(id) {
            this.allocated[id] = undefined;
            this.freelist.push(id)
          }
        })
      }

      function HandleAllocator() {
        this.allocated = [undefined];
        this.freelist = []
      }

      var emval_handles = new HandleAllocator;
      var __emval_decref = handle => {
        if (handle >= emval_handles.reserved && 0 === --emval_handles.get(
          handle).refcount) {
          emval_handles.free(handle)
        }
      };
      var count_emval_handles = () => {
        var count = 0;
        for (var i = emval_handles.reserved; i < emval_handles.allocated.length;
          ++i) {
          if (emval_handles.allocated[i] !== undefined) {
            ++count
          }
        }
        return count
      };
      var init_emval = () => {
        emval_handles.allocated.push({value: undefined}, {value: null},
          {value: true}, {value: false});
        emval_handles.reserved = emval_handles.allocated.length;
        Module["count_emval_handles"] = count_emval_handles
      };
      var Emval = {
        toValue: handle => {
          if (!handle) {
            throwBindingError("Cannot use deleted val. handle = " + handle)
          }
          return emval_handles.get(handle).value
        }, toHandle: value => {
          switch (value) {
            case undefined:
              return 1;
            case null:
              return 2;
            case true:
              return 3;
            case false:
              return 4;
            default: {
              return emval_handles.allocate({refcount: 1, value: value})
            }
          }
        }
      };

      function simpleReadValueFromPointer(pointer) {
        return this["fromWireType"](HEAP32[pointer >> 2])
      }

      var __embind_register_emval = (rawType, name) => {
        name = readLatin1String(name);
        registerType(rawType, {
          name: name,
          "fromWireType": handle => {
            var rv = Emval.toValue(handle);
            __emval_decref(handle);
            return rv
          },
          "toWireType": (destructors, value) => Emval.toHandle(value),
          "argPackAdvance": GenericWireTypeSize,
          "readValueFromPointer": simpleReadValueFromPointer,
          destructorFunction: null
        })
      };
      var embindRepr = v => {
        if (v === null) {
          return "null"
        }
        var t = typeof v;
        if (t === "object" || t === "array" || t === "function") {
          return v.toString()
        } else {
          return "" + v
        }
      };
      var floatReadValueFromPointer = (name, width) => {
        switch (width) {
          case 4:
            return function (pointer) {
              return this["fromWireType"](HEAPF32[pointer >> 2])
            };
          case 8:
            return function (pointer) {
              return this["fromWireType"](HEAPF64[pointer >> 3])
            };
          default:
            throw new TypeError(`invalid float width (${width}): ${name}`)
        }
      };
      var __embind_register_float = (rawType, name, size) => {
        name = readLatin1String(name);
        registerType(rawType, {
          name: name,
          "fromWireType": value => value,
          "toWireType": (destructors, value) => value,
          "argPackAdvance": GenericWireTypeSize,
          "readValueFromPointer": floatReadValueFromPointer(name, size),
          destructorFunction: null
        })
      };
      var integerReadValueFromPointer = (name, width, signed) => {
        switch (width) {
          case 1:
            return signed ? pointer => HEAP8[pointer >> 0]
              : pointer => HEAPU8[pointer >> 0];
          case 2:
            return signed ? pointer => HEAP16[pointer >> 1]
              : pointer => HEAPU16[pointer >> 1];
          case 4:
            return signed ? pointer => HEAP32[pointer >> 2]
              : pointer => HEAPU32[pointer >> 2];
          default:
            throw new TypeError(`invalid integer width (${width}): ${name}`)
        }
      };
      var __embind_register_integer = (primitiveType, name, size, minRange,
        maxRange) => {
        name = readLatin1String(name);
        if (maxRange === -1) {
          maxRange = 4294967295
        }
        var fromWireType = value => value;
        if (minRange === 0) {
          var bitshift = 32 - 8 * size;
          fromWireType = value => value << bitshift >>> bitshift
        }
        var isUnsignedType = name.includes("unsigned");
        var checkAssertions = (value, toTypeName) => {
        };
        var toWireType;
        if (isUnsignedType) {
          toWireType = function (destructors, value) {
            checkAssertions(value, this.name);
            return value >>> 0
          }
        } else {
          toWireType = function (destructors, value) {
            checkAssertions(value, this.name);
            return value
          }
        }
        registerType(primitiveType, {
          name: name,
          "fromWireType": fromWireType,
          "toWireType": toWireType,
          "argPackAdvance": GenericWireTypeSize,
          "readValueFromPointer": integerReadValueFromPointer(name, size,
            minRange !== 0),
          destructorFunction: null
        })
      };
      var __embind_register_memory_view = (rawType, dataTypeIndex, name) => {
        var typeMapping = [Int8Array, Uint8Array, Int16Array, Uint16Array,
          Int32Array, Uint32Array, Float32Array, Float64Array];
        var TA = typeMapping[dataTypeIndex];

        function decodeMemoryView(handle) {
          var size = HEAPU32[handle >> 2];
          var data = HEAPU32[handle + 4 >> 2];
          return new TA(HEAP8.buffer, data, size)
        }

        name = readLatin1String(name);
        registerType(rawType, {
          name: name,
          "fromWireType": decodeMemoryView,
          "argPackAdvance": GenericWireTypeSize,
          "readValueFromPointer": decodeMemoryView
        }, {ignoreDuplicateRegistrations: true})
      };
      var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
        if (!(maxBytesToWrite > 0)) {
          return 0;
        }
        var startIdx = outIdx;
        var endIdx = outIdx + maxBytesToWrite - 1;
        for (var i = 0; i < str.length; ++i) {
          var u = str.charCodeAt(i);
          if (u >= 55296 && u <= 57343) {
            var u1 = str.charCodeAt(++i);
            u = 65536 + ((u & 1023) << 10) | u1 & 1023
          }
          if (u <= 127) {
            if (outIdx >= endIdx) {
              break;
            }
            heap[outIdx++] = u
          } else if (u <= 2047) {
            if (outIdx + 1 >= endIdx) {
              break;
            }
            heap[outIdx++] = 192 | u >> 6;
            heap[outIdx++] = 128 | u & 63
          } else if (u <= 65535) {
            if (outIdx + 2 >= endIdx) {
              break;
            }
            heap[outIdx++] = 224 | u >> 12;
            heap[outIdx++] = 128 | u >> 6 & 63;
            heap[outIdx++] = 128 | u & 63
          } else {
            if (outIdx + 3 >= endIdx) {
              break;
            }
            heap[outIdx++] = 240 | u >> 18;
            heap[outIdx++] = 128 | u >> 12 & 63;
            heap[outIdx++] = 128 | u >> 6 & 63;
            heap[outIdx++] = 128 | u & 63
          }
        }
        heap[outIdx] = 0;
        return outIdx - startIdx
      };
      var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(
        str, HEAPU8, outPtr, maxBytesToWrite);
      var lengthBytesUTF8 = str => {
        var len = 0;
        for (var i = 0; i < str.length; ++i) {
          var c = str.charCodeAt(i);
          if (c <= 127) {
            len++
          } else if (c <= 2047) {
            len += 2
          } else if (c >= 55296 && c <= 57343) {
            len += 4;
            ++i
          } else {
            len += 3
          }
        }
        return len
      };
      var __embind_register_std_string = (rawType, name) => {
        name = readLatin1String(name);
        var stdStringIsUTF8 = name === "std::string";
        registerType(rawType, {
          name: name,
          "fromWireType"(value) {
            var length = HEAPU32[value >> 2];
            var payload = value + 4;
            var str;
            if (stdStringIsUTF8) {
              var decodeStartPtr = payload;
              for (var i = 0; i <= length; ++i) {
                var currentBytePtr = payload + i;
                if (i == length || HEAPU8[currentBytePtr] == 0) {
                  var maxRead = currentBytePtr - decodeStartPtr;
                  var stringSegment = UTF8ToString(decodeStartPtr, maxRead);
                  if (str === undefined) {
                    str = stringSegment
                  } else {
                    str += String.fromCharCode(0);
                    str += stringSegment
                  }
                  decodeStartPtr = currentBytePtr + 1
                }
              }
            } else {
              var a = new Array(length);
              for (var i = 0; i < length; ++i) {
                a[i] = String.fromCharCode(HEAPU8[payload + i])
              }
              str = a.join("")
            }
            _free(value);
            return str
          },
          "toWireType"(destructors, value) {
            if (value instanceof ArrayBuffer) {
              value = new Uint8Array(value)
            }
            var length;
            var valueIsOfTypeString = typeof value == "string";
            if (!(valueIsOfTypeString || value instanceof Uint8Array || value
              instanceof Uint8ClampedArray || value instanceof Int8Array)) {
              throwBindingError("Cannot pass non-string to std::string")
            }
            if (stdStringIsUTF8 && valueIsOfTypeString) {
              length = lengthBytesUTF8(value)
            } else {
              length = value.length
            }
            var base = _malloc(4 + length + 1);
            var ptr = base + 4;
            HEAPU32[base >> 2] = length;
            if (stdStringIsUTF8 && valueIsOfTypeString) {
              stringToUTF8(value, ptr, length + 1)
            } else {
              if (valueIsOfTypeString) {
                for (var i = 0; i < length; ++i) {
                  var charCode = value.charCodeAt(i);
                  if (charCode > 255) {
                    _free(ptr);
                    throwBindingError(
                      "String has UTF-16 code units that do not fit in 8 bits")
                  }
                  HEAPU8[ptr + i] = charCode
                }
              } else {
                for (var i = 0; i < length; ++i) {
                  HEAPU8[ptr + i] = value[i]
                }
              }
            }
            if (destructors !== null) {
              destructors.push(_free, base)
            }
            return base
          },
          "argPackAdvance": GenericWireTypeSize,
          "readValueFromPointer": readPointer,
          destructorFunction(ptr) {
            _free(ptr)
          }
        })
      };
      var UTF16Decoder = typeof TextDecoder != "undefined" ? new TextDecoder(
        "utf-16le") : undefined;
      var UTF16ToString = (ptr, maxBytesToRead) => {
        var endPtr = ptr;
        var idx = endPtr >> 1;
        var maxIdx = idx + maxBytesToRead / 2;
        while (!(idx >= maxIdx) && HEAPU16[idx]) {
          ++idx;
        }
        endPtr = idx << 1;
        if (endPtr - ptr > 32 && UTF16Decoder) {
          return UTF16Decoder.decode(
            HEAPU8.slice(ptr, endPtr));
        }
        var str = "";
        for (var i = 0; !(i >= maxBytesToRead / 2); ++i) {
          var codeUnit = HEAP16[ptr + i * 2 >> 1];
          if (codeUnit == 0) {
            break;
          }
          str += String.fromCharCode(codeUnit)
        }
        return str
      };
      var stringToUTF16 = (str, outPtr, maxBytesToWrite) => {
        if (maxBytesToWrite === undefined) {
          maxBytesToWrite = 2147483647
        }
        if (maxBytesToWrite < 2) {
          return 0;
        }
        maxBytesToWrite -= 2;
        var startPtr = outPtr;
        var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite
          / 2 : str.length;
        for (var i = 0; i < numCharsToWrite; ++i) {
          var codeUnit = str.charCodeAt(i);
          HEAP16[outPtr >> 1] = codeUnit;
          outPtr += 2
        }
        HEAP16[outPtr >> 1] = 0;
        return outPtr - startPtr
      };
      var lengthBytesUTF16 = str => str.length * 2;
      var UTF32ToString = (ptr, maxBytesToRead) => {
        var i = 0;
        var str = "";
        while (!(i >= maxBytesToRead / 4)) {
          var utf32 = HEAP32[ptr + i * 4 >> 2];
          if (utf32 == 0) {
            break;
          }
          ++i;
          if (utf32 >= 65536) {
            var ch = utf32 - 65536;
            str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023)
          } else {
            str += String.fromCharCode(utf32)
          }
        }
        return str
      };
      var stringToUTF32 = (str, outPtr, maxBytesToWrite) => {
        if (maxBytesToWrite === undefined) {
          maxBytesToWrite = 2147483647
        }
        if (maxBytesToWrite < 4) {
          return 0;
        }
        var startPtr = outPtr;
        var endPtr = startPtr + maxBytesToWrite - 4;
        for (var i = 0; i < str.length; ++i) {
          var codeUnit = str.charCodeAt(i);
          if (codeUnit >= 55296 && codeUnit <= 57343) {
            var trailSurrogate = str.charCodeAt(++i);
            codeUnit = 65536 + ((codeUnit & 1023) << 10) | trailSurrogate & 1023
          }
          HEAP32[outPtr >> 2] = codeUnit;
          outPtr += 4;
          if (outPtr + 4 > endPtr) {
            break
          }
        }
        HEAP32[outPtr >> 2] = 0;
        return outPtr - startPtr
      };
      var lengthBytesUTF32 = str => {
        var len = 0;
        for (var i = 0; i < str.length; ++i) {
          var codeUnit = str.charCodeAt(i);
          if (codeUnit >= 55296 && codeUnit <= 57343) {
            ++i;
          }
          len += 4
        }
        return len
      };
      var __embind_register_std_wstring = (rawType, charSize, name) => {
        name = readLatin1String(name);
        var decodeString, encodeString, getHeap, lengthBytesUTF, shift;
        if (charSize === 2) {
          decodeString = UTF16ToString;
          encodeString = stringToUTF16;
          lengthBytesUTF = lengthBytesUTF16;
          getHeap = () => HEAPU16;
          shift = 1
        } else if (charSize === 4) {
          decodeString = UTF32ToString;
          encodeString = stringToUTF32;
          lengthBytesUTF = lengthBytesUTF32;
          getHeap = () => HEAPU32;
          shift = 2
        }
        registerType(rawType, {
          name: name,
          "fromWireType": value => {
            var length = HEAPU32[value >> 2];
            var HEAP = getHeap();
            var str;
            var decodeStartPtr = value + 4;
            for (var i = 0; i <= length; ++i) {
              var currentBytePtr = value + 4 + i * charSize;
              if (i == length || HEAP[currentBytePtr >> shift] == 0) {
                var maxReadBytes = currentBytePtr - decodeStartPtr;
                var stringSegment = decodeString(decodeStartPtr, maxReadBytes);
                if (str === undefined) {
                  str = stringSegment
                } else {
                  str += String.fromCharCode(0);
                  str += stringSegment
                }
                decodeStartPtr = currentBytePtr + charSize
              }
            }
            _free(value);
            return str
          },
          "toWireType": (destructors, value) => {
            if (!(typeof value == "string")) {
              throwBindingError(
                `Cannot pass non-string to C++ string type ${name}`)
            }
            var length = lengthBytesUTF(value);
            var ptr = _malloc(4 + length + charSize);
            HEAPU32[ptr >> 2] = length >> shift;
            encodeString(value, ptr + 4, length + charSize);
            if (destructors !== null) {
              destructors.push(_free, ptr)
            }
            return ptr
          },
          "argPackAdvance": GenericWireTypeSize,
          "readValueFromPointer": simpleReadValueFromPointer,
          destructorFunction(ptr) {
            _free(ptr)
          }
        })
      };
      var __embind_register_void = (rawType, name) => {
        name = readLatin1String(name);
        registerType(rawType, {
          isVoid: true,
          name: name,
          "argPackAdvance": 0,
          "fromWireType": () => undefined,
          "toWireType": (destructors, o) => undefined
        })
      };
      var maybeExit = () => {
        if (!keepRuntimeAlive()) {
          try {
            if (ENVIRONMENT_IS_PTHREAD) {
              __emscripten_thread_exit(
                EXITSTATUS);
            } else {
              _exit(EXITSTATUS)
            }
          } catch (e) {
            handleException(e)
          }
        }
      };
      var callUserCallback = func => {
        if (ABORT) {
          return
        }
        try {
          func();
          maybeExit()
        } catch (e) {
          handleException(e)
        }
      };
      var __emscripten_thread_mailbox_await = pthread_ptr => {
        if (typeof Atomics.waitAsync === "function") {
          var wait = Atomics.waitAsync(HEAP32, pthread_ptr >> 2, pthread_ptr);
          wait.value.then(checkMailbox);
          var waitingAsync = pthread_ptr + 128;
          Atomics.store(HEAP32, waitingAsync >> 2, 1)
        }
      };
      Module["__emscripten_thread_mailbox_await"] = __emscripten_thread_mailbox_await;
      var checkMailbox = () => {
        var pthread_ptr = _pthread_self();
        if (pthread_ptr) {
          __emscripten_thread_mailbox_await(pthread_ptr);
          callUserCallback(() => __emscripten_check_mailbox())
        }
      };
      Module["checkMailbox"] = checkMailbox;
      var __emscripten_notify_mailbox_postmessage = (targetThreadId,
        currThreadId, mainThreadId) => {
        if (targetThreadId == currThreadId) {
          setTimeout(() => checkMailbox())
        } else if (ENVIRONMENT_IS_PTHREAD) {
          postMessage({"targetThread": targetThreadId, "cmd": "checkMailbox"})
        } else {
          var worker = PThread.pthreads[targetThreadId];
          if (!worker) {
            return
          }
          worker.postMessage({"cmd": "checkMailbox"})
        }
      };
      var withStackSave = f => {
        var stack = stackSave();
        var ret = f();
        stackRestore(stack);
        return ret
      };
      var proxyToMainThread = function (index, sync) {
        var numCallArgs = arguments.length - 2;
        var outerArgs = arguments;
        return withStackSave(() => {
          var serializedNumCallArgs = numCallArgs;
          var args = stackAlloc(serializedNumCallArgs * 8);
          var b = args >> 3;
          for (var i = 0; i < numCallArgs; i++) {
            var arg = outerArgs[2 + i];
            HEAPF64[b + i] = arg
          }
          return __emscripten_run_on_main_thread_js(index,
            serializedNumCallArgs, args, sync)
        })
      };
      var proxiedJSCallArgs = [];
      var __emscripten_receive_on_main_thread_js = (index, callingThread,
        numCallArgs, args) => {
        proxiedJSCallArgs.length = numCallArgs;
        var b = args >> 3;
        for (var i = 0; i < numCallArgs; i++) {
          proxiedJSCallArgs[i] = HEAPF64[b + i]
        }
        var func = proxiedFunctionTable[index];
        PThread.currentProxiedOperationCallerThread = callingThread;
        var rtn = func.apply(null, proxiedJSCallArgs);
        PThread.currentProxiedOperationCallerThread = 0;
        return rtn
      };
      var __emscripten_thread_set_strongref = thread => {
        if (ENVIRONMENT_IS_NODE) {
          PThread.pthreads[thread].ref()
        }
      };
      var emval_symbols = {};
      var getStringOrSymbol = address => {
        var symbol = emval_symbols[address];
        if (symbol === undefined) {
          return readLatin1String(address)
        }
        return symbol
      };
      var emval_methodCallers = [];
      var __emval_call_void_method = (caller, handle, methodName, args) => {
        caller = emval_methodCallers[caller];
        handle = Emval.toValue(handle);
        methodName = getStringOrSymbol(methodName);
        caller(handle, methodName, null, args)
      };
      var emval_addMethodCaller = caller => {
        var id = emval_methodCallers.length;
        emval_methodCallers.push(caller);
        return id
      };
      var requireRegisteredType = (rawType, humanName) => {
        var impl = registeredTypes[rawType];
        if (undefined === impl) {
          throwBindingError(
            humanName + " has unknown type " + getTypeName(rawType))
        }
        return impl
      };
      var emval_lookupTypes = (argCount, argTypes) => {
        var a = new Array(argCount);
        for (var i = 0; i < argCount; ++i) {
          a[i] = requireRegisteredType(HEAPU32[argTypes + i * 4 >> 2],
            "parameter " + i)
        }
        return a
      };
      var emval_registeredMethods = {};
      var __emval_get_method_caller = (argCount, argTypes) => {
        var types = emval_lookupTypes(argCount, argTypes);
        var retType = types[0];
        var signatureName = retType.name + "_$" + types.slice(1).map(
          function (t) {
            return t.name
          }).join("_") + "$";
        var returnId = emval_registeredMethods[signatureName];
        if (returnId !== undefined) {
          return returnId
        }
        var params = ["retType"];
        var args = [retType];
        var argsList = "";
        for (var i = 0; i < argCount - 1; ++i) {
          argsList += (i !== 0 ? ", " : "") + "arg" + i;
          params.push("argType" + i);
          args.push(types[1 + i])
        }
        var functionName = makeLegalFunctionName(
          "methodCaller_" + signatureName);
        var functionBody = "return function " + functionName
          + "(handle, name, destructors, args) {\n";
        var offset = 0;
        for (var i = 0; i < argCount - 1; ++i) {
          functionBody += "    var arg" + i + " = argType" + i
            + ".readValueFromPointer(args" + (offset ? "+" + offset : "")
            + ");\n";
          offset += types[i + 1]["argPackAdvance"]
        }
        functionBody += "    var rv = handle[name](" + argsList + ");\n";
        for (var i = 0; i < argCount - 1; ++i) {
          if (types[i + 1]["deleteObject"]) {
            functionBody += "    argType" + i + ".deleteObject(arg" + i + ");\n"
          }
        }
        if (!retType.isVoid) {
          functionBody += "    return retType.toWireType(destructors, rv);\n"
        }
        functionBody += "};\n";
        params.push(functionBody);
        var invokerFunction = newFunc(Function, params).apply(null, args);
        returnId = emval_addMethodCaller(invokerFunction);
        emval_registeredMethods[signatureName] = returnId;
        return returnId
      };
      var __emval_incref = handle => {
        if (handle > 4) {
          emval_handles.get(handle).refcount += 1
        }
      };
      var __emval_new_cstring = v => Emval.toHandle(getStringOrSymbol(v));
      var __emval_new_object = () => Emval.toHandle({});
      var __emval_new_u8string = v => Emval.toHandle(UTF8ToString(v));
      var __emval_set_property = (handle, key, value) => {
        handle = Emval.toValue(handle);
        key = Emval.toValue(key);
        value = Emval.toValue(value);
        handle[key] = value
      };
      var __emval_take_value = (type, arg) => {
        type = requireRegisteredType(type, "_emval_take_value");
        var v = type["readValueFromPointer"](arg);
        return Emval.toHandle(v)
      };
      var _abort = () => {
        abort("")
      };
      var warnOnce = text => {
        if (!warnOnce.shown) {
          warnOnce.shown = {};
        }
        if (!warnOnce.shown[text]) {
          warnOnce.shown[text] = 1;
          if (ENVIRONMENT_IS_NODE) {
            text = "warning: " + text;
          }
          err(text)
        }
      };
      var _emscripten_check_blocking_allowed = () => {
      };
      var runtimeKeepalivePush = () => {
        runtimeKeepaliveCounter += 1
      };
      var _emscripten_exit_with_live_runtime = () => {
        runtimeKeepalivePush();
        throw "unwind"
      };
      var _emscripten_get_now;
      _emscripten_get_now = () => performance.timeOrigin + performance.now();
      var abortOnCannotGrowMemory = requestedSize => {
        abort("OOM")
      };
      var _emscripten_resize_heap = requestedSize => {
        var oldSize = HEAPU8.length;
        requestedSize >>>= 0;
        abortOnCannotGrowMemory(requestedSize)
      };
      var printCharBuffers = [null, [], []];
      var printChar = (stream, curr) => {
        var buffer = printCharBuffers[stream];
        if (curr === 0 || curr === 10) {
          (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
          buffer.length = 0
        } else {
          buffer.push(curr)
        }
      };

      function _fd_write(fd, iov, iovcnt, pnum) {
        if (ENVIRONMENT_IS_PTHREAD) {
          return proxyToMainThread(3, 1, fd, iov,
            iovcnt, pnum);
        }
        var num = 0;
        for (var i = 0; i < iovcnt; i++) {
          var ptr = HEAPU32[iov >> 2];
          var len = HEAPU32[iov + 4 >> 2];
          iov += 8;
          for (var j = 0; j < len; j++) {
            printChar(fd, HEAPU8[ptr + j])
          }
          num += len
        }
        HEAPU32[pnum >> 2] = num;
        return 0
      }

      PThread.init();
      embind_init_charCodes();
      BindingError = Module["BindingError"] = class BindingError extends Error {
        constructor(message) {
          super(message);
          this.name = "BindingError"
        }
      };
      InternalError = Module["InternalError"] = class InternalError extends Error {
        constructor(message) {
          super(message);
          this.name = "InternalError"
        }
      };
      init_ClassHandle();
      init_embind();
      init_RegisteredPointer();
      UnboundTypeError = Module["UnboundTypeError"] = extendError(Error,
        "UnboundTypeError");
      handleAllocatorInit();
      init_emval();
      var proxiedFunctionTable = [_proc_exit, exitOnMainThread,
        pthreadCreateProxied, _fd_write];
      var wasmImports = {
        q: ___cxa_throw,
        A: ___emscripten_init_main_thread_js,
        l: ___emscripten_thread_cleanup,
        y: ___pthread_create_js,
        s: __embind_register_bigint,
        G: __embind_register_bool,
        w: __embind_register_class,
        r: __embind_register_class_constructor,
        h: __embind_register_class_function,
        F: __embind_register_emval,
        n: __embind_register_float,
        c: __embind_register_integer,
        b: __embind_register_memory_view,
        o: __embind_register_std_string,
        i: __embind_register_std_wstring,
        H: __embind_register_void,
        u: __emscripten_notify_mailbox_postmessage,
        B: __emscripten_receive_on_main_thread_js,
        z: __emscripten_thread_mailbox_await,
        D: __emscripten_thread_set_strongref,
        g: __emval_call_void_method,
        d: __emval_decref,
        f: __emval_get_method_caller,
        I: __emval_incref,
        p: __emval_new_cstring,
        K: __emval_new_object,
        E: __emval_new_u8string,
        j: __emval_set_property,
        J: __emval_take_value,
        k: _abort,
        m: _emscripten_check_blocking_allowed,
        C: _emscripten_exit_with_live_runtime,
        e: _emscripten_get_now,
        t: _emscripten_resize_heap,
        x: _exit,
        v: _fd_write,
        a: wasmMemory || Module["wasmMemory"]
      };
      var wasmExports = createWasm();
      var ___wasm_call_ctors = () => (___wasm_call_ctors = wasmExports["L"])();
      var _free = a0 => (_free = wasmExports["M"])(a0);
      var _malloc = a0 => (_malloc = wasmExports["N"])(a0);
      var __emscripten_tls_init = Module["__emscripten_tls_init"] = () => (__emscripten_tls_init = Module["__emscripten_tls_init"] = wasmExports["O"])();
      var _pthread_self = Module["_pthread_self"] = () => (_pthread_self = Module["_pthread_self"] = wasmExports["P"])();
      var ___getTypeName = a0 => (___getTypeName = wasmExports["Q"])(a0);
      var __embind_initialize_bindings = Module["__embind_initialize_bindings"] = () => (__embind_initialize_bindings = Module["__embind_initialize_bindings"] = wasmExports["R"])();
      var ___errno_location = () => (___errno_location = wasmExports["__errno_location"])();
      var __emscripten_thread_init = Module["__emscripten_thread_init"] = (a0,
        a1, a2, a3, a4,
        a5) => (__emscripten_thread_init = Module["__emscripten_thread_init"] = wasmExports["S"])(
        a0, a1, a2, a3, a4, a5);
      var __emscripten_thread_crashed = Module["__emscripten_thread_crashed"] = () => (__emscripten_thread_crashed = Module["__emscripten_thread_crashed"] = wasmExports["U"])();
      var _emscripten_main_runtime_thread_id = () => (_emscripten_main_runtime_thread_id = wasmExports["emscripten_main_runtime_thread_id"])();
      var _emscripten_main_thread_process_queued_calls = () => (_emscripten_main_thread_process_queued_calls = wasmExports["emscripten_main_thread_process_queued_calls"])();
      var __emscripten_run_on_main_thread_js = (a0, a1, a2,
        a3) => (__emscripten_run_on_main_thread_js = wasmExports["V"])(a0, a1,
        a2, a3);
      var __emscripten_thread_free_data = a0 => (__emscripten_thread_free_data = wasmExports["W"])(
        a0);
      var __emscripten_thread_exit = Module["__emscripten_thread_exit"] = a0 => (__emscripten_thread_exit = Module["__emscripten_thread_exit"] = wasmExports["X"])(
        a0);
      var __emscripten_check_mailbox = Module["__emscripten_check_mailbox"] = () => (__emscripten_check_mailbox = Module["__emscripten_check_mailbox"] = wasmExports["Y"])();
      var _emscripten_stack_set_limits = (a0,
        a1) => (_emscripten_stack_set_limits = wasmExports["Z"])(a0, a1);
      var stackSave = () => (stackSave = wasmExports["_"])();
      var stackRestore = a0 => (stackRestore = wasmExports["$"])(a0);
      var stackAlloc = a0 => (stackAlloc = wasmExports["aa"])(a0);
      var ___cxa_increment_exception_refcount = a0 => (___cxa_increment_exception_refcount = wasmExports["__cxa_increment_exception_refcount"])(
        a0);
      var ___cxa_is_pointer_type = a0 => (___cxa_is_pointer_type = wasmExports["ba"])(
        a0);
      var dynCall_jiji = Module["dynCall_jiji"] = (a0, a1, a2, a3,
        a4) => (dynCall_jiji = Module["dynCall_jiji"] = wasmExports["ca"])(a0,
        a1, a2, a3, a4);
      var ___start_em_js = Module["___start_em_js"] = 143356;
      var ___stop_em_js = Module["___stop_em_js"] = 143413;
      Module["keepRuntimeAlive"] = keepRuntimeAlive;
      Module["wasmMemory"] = wasmMemory;
      Module["ExitStatus"] = ExitStatus;
      Module["PThread"] = PThread;
      var calledRun;
      dependenciesFulfilled = function runCaller() {
        if (!calledRun) {
          run();
        }
        if (!calledRun) {
          dependenciesFulfilled = runCaller
        }
      };

      function run() {
        if (runDependencies > 0) {
          return
        }
        if (ENVIRONMENT_IS_PTHREAD) {
          readyPromiseResolve(Module);
          initRuntime();
          startWorker(Module);
          return
        }
        preRun();
        if (runDependencies > 0) {
          return
        }

        function doRun() {
          if (calledRun) {
            return;
          }
          calledRun = true;
          Module["calledRun"] = true;
          if (ABORT) {
            return;
          }
          initRuntime();
          readyPromiseResolve(Module);
          if (Module["onRuntimeInitialized"]) {
            Module["onRuntimeInitialized"]();
          }
          postRun()
        }

        if (Module["setStatus"]) {
          Module["setStatus"]("Running...");
          setTimeout(function () {
            setTimeout(function () {
              Module["setStatus"]("")
            }, 1);
            doRun()
          }, 1)
        } else {
          doRun()
        }
      }

      if (Module["preInit"]) {
        if (typeof Module["preInit"]
          == "function") {
          Module["preInit"] = [Module["preInit"]];
        }
        while (Module["preInit"].length > 0) {
          Module["preInit"].pop()()
        }
      }
      run();

      return moduleArg.ready
    }

  );
})();
export default Module;